package com.xbongbong.paas.enums;

import com.xbongbong.i18n.util.I18nMessageUtil;
import com.xbongbong.paas.constant.PaasConstant;
import lombok.Getter;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;

/**
 * 阶段类型枚举
 * @author 李少杰
 * @version v1.0.0
 * @date 2021/11/22 11:21
 */
@Getter
public enum StageTypeEnum {
    /**
     * 开始阶段(未入库的阶段)
     */
    START_STAGE(-1, "enum.stage.process.name.stage_type_start", "开始阶段"),
    /**
     * 普通阶段
     */
    ORDINARY_STAGE(0, "enum.stage.process.name.stage_type_ordinary", "普通阶段"),

    /**
     * 结束阶段-成功
     */
    SUCCESS_STAGE(1, "enum.stage.process.name.stage_type_success", "结束阶段-成功"),

    /**
     * 结束阶段-失败
     */
    FAIL_STAGE(2, "enum.stage.process.name.stage_type_fail", "结束阶段-失败"),

    /**
     * 结束阶段-取消
     */
    CANCEL_STAGE(3, "enum.stage.process.name.stage_type_cancel", "结束阶段-取消"),
    ;

    /**
     * 阶段类型值
     */
    private final Integer type;
    /**
     * 阶段类型名称
     */
    private final String name;
    /**
     * 阶段类型说明
     */
    private final String description;

    StageTypeEnum(Integer type, String name, String description) {
        this.type = type;
        this.name = name;
        this.description = description;
    }

    public String getName() {
        return I18nMessageUtil.getMessage(name);
    }

    public static StageTypeEnum getByType(Integer type) {
        for (StageTypeEnum stageTypeEnum : values()) {
            if (Objects.equals(stageTypeEnum.getType(), type)) {
                return stageTypeEnum;
            }
        }
        return null;
    }

    /**
     * 获取全部枚举
     */
    public static List<StageTypeEnum> getAllEnum() {
        List<StageTypeEnum> list = new ArrayList<>();
        for (StageTypeEnum cache : values()) {
            if (cache == null) {
                continue;
            }
            list.add(cache);
        }
        return list;
    }

    /**
     * 获取全部type
     * @return java.util.List<java.lang.Integer>
     * @author zcp
     * @since v1.0
     * @version v1.0
     */
    public static List<Integer> getAllType() {
        List<Integer> list = new ArrayList<>();
        for (StageTypeEnum cache : values()) {
            if (cache == null) {
                continue;
            }
            list.add(cache.type);
        }
        return list;
    }

    /**
     * 获取非开始阶段的类型
     * @return
     */
    public static List<Integer> getNotStartType(){
        return Arrays.asList(ORDINARY_STAGE.type, SUCCESS_STAGE.type, FAIL_STAGE.type, CANCEL_STAGE.type);
    }

    /**
     * 获取普通类型
     * @return java.util.List<java.lang.Integer>
     * @author zcp
     * @since v1.0
     * @version v1.0
     */
    public static List<Integer> getOrdinaryType(){
        return Arrays.asList(ORDINARY_STAGE.type);
    }

    /**
     * 获取结束类型
     * @return
     */
    public static List<Integer> getEndType() {
        return Arrays.asList(SUCCESS_STAGE.type, FAIL_STAGE.type, CANCEL_STAGE.type);
    }
    /**
     * 结束阶段按顺序塞入map，强制按照“成功 - 失败 - 取消”排序
     * @return java.util.Map<java.lang.Integer,java.util.List>
     * @author zcp
     * @since v1.0
     * @version v1.0
     */
    public static Map<Integer, List> getEndTypeMap(){
        //结束类型（结束阶段-成功、结束阶段-失败、结束阶段-取消）
        List<Integer> endTypeList = Arrays.asList(SUCCESS_STAGE.type, FAIL_STAGE.type, CANCEL_STAGE.type);
        //类型 - 该类型下的阶段集合
        Map<Integer, List> map = new LinkedHashMap<>(PaasConstant.DEFAULT_INITIAL_CAPACITY);
        for (Integer type : endTypeList) {
            map.put(type, new ArrayList<>());
        }
        return map;
    }

    /**
     * 成功类型
     * @return java.util.List<java.lang.Integer>
     * @author zcp
     * @since v1.0
     * @version v1.0
     */
    public static List<Integer> getSuccessType(){
        return Arrays.asList(SUCCESS_STAGE.type);
    }

    /**
     * 失败类型
     * @return java.util.List<java.lang.Integer>
     * @author zcp
     * @since v1.0
     * @version v1.0
     */
    public static List<Integer> getLoseType() {
        return Arrays.asList(FAIL_STAGE.type);
    }

    /**
     * 获取【非取消】类型
     * @return java.util.List<java.lang.Integer>
     * @author zcp
     * @since v1.0
     * @version v1.0
     */
    public static List<Integer> getExceptCancelType(){
        List<Integer> list = getAllType();
        list.remove(CANCEL_STAGE.type);
        return list;
    }
    /**
     * 获取【非失败、非取消】类型
     * @return java.util.List<java.lang.Integer>
     * @author zcp
     * @since v1.0
     * @version v1.0
     */
    public static List<Integer> getExceptLoseCancelType(){
        //剔除失败、取消类型
        return getExceptTypeIn(getLoseCancelType());
    }
    /**
     * 失败、取消类型
     * @return java.util.List<java.lang.Integer>
     * @author zcp
     * @since v1.0
     * @version v1.0
     */
    public static List<Integer> getLoseCancelType() {
        return Arrays.asList(FAIL_STAGE.type, CANCEL_STAGE.type);
    }
    /**
     * 获取除typeIn之外的类型
     * @param notFindTypeIn 不获取的阶段类型
     * @return java.util.List<java.lang.Integer>
     * @author zcp
     * @since v1.0
     * @version v1.0
     */
    private static List<Integer> getExceptTypeIn(List<Integer> notFindTypeIn){
        List<Integer> allType = getAllType();
        allType.removeAll(notFindTypeIn);
        return allType;
    }
}
